Instance 0

ResponseMode.parse(final String s)#2{
    if (StringUtils.isBlank(s))
      return null;
}


Instance 1

ResponseType.parse(final String s)#1{
    if (StringUtils.isBlank(s))
      throw new ParseException("Null or empty response type string");
}


Instance 2

Grok.compile(String pattern)#3{
    if (StringUtils.isBlank(pattern))
      throw new GrokException("{pattern} should not be empty or null");
}


Instance 3

Grok.create(String grokPatternPath,String grokExpression)#1{
    if (StringUtils.isBlank(grokPatternPath))
      throw new GrokException("{grokPatternPath} should not be empty or null");
}


Instance 4

Secret.Secret(final String value,final Date expDate)#0{
    if (StringUtils.isBlank(value))
      throw new IllegalArgumentException("The value must not be null or empty string");
}


Instance 5

LoggingHttpProxy.fromString(String function)#3{
        if (StringUtils.isBlank(function)) {
            throw new IllegalArgumentException("SearchFunction is null");
        }
}


Instance 6

Prompt.parse(final String s)#1{
    if (StringUtils.isBlank(s))
      return null;
}


Instance 7

Identifier.Identifier(final String value)#0{
    if (StringUtils.isBlank(value))
      throw new IllegalArgumentException("The value must not be null or empty string");
}


Instance 8

FormatsScriptTags.fromString(String type)#0{
        if (StringUtils.isBlank(type)) {
            throw new IllegalArgumentException("SearchType is null");
        }
}


Instance 9

SubBabaApi.SubBabaApi(String apiKey,CommonHttpClient httpClient)#3{
        if (StringUtils.isBlank(apiKey)) {
            throw new WebServiceException("Invalid API Key");
        }
}


Instance 10

RenderTagHandler.parse(final String s)#0{
    if (StringUtils.isBlank(s))
      return getDefault();
    if (s.equals("page"))
      return PAGE;
    if (s.equals("popup"))
      return POPUP;
    if (s.equals("touch"))
      return TOUCH;
    if (s.equals("wap"))
      return WAP;
    throw new ParseException("Unknown display type: " + s);
}


Instance 11

BlobCrypterSecurityTokenCodec.createToken(Map<String,String> tokenParameters)#0{
    String token = tokenParameters.get(SecurityTokenCodec.SECURITY_TOKEN_NAME);
    if (StringUtils.isBlank(token)) {
      // No token is present, assume anonymous access
      return new AnonymousSecurityToken();
    }
    String[] fields = StringUtils.split(token, ':');
}


Instance 12

LogoutRequest.parse(final URI uri,final Map<String,String> params)#1{
    String v = params.get("id_token_hint");
    if (StringUtils.isBlank(v))
      throw new ParseException("Missing \"id_token_hint\" parameter");
      idTokenHint = JWTParser.parse(v);
}


Instance 13

BearerAccessToken.parse(final String header)#5{
    if (StringUtils.isBlank(header))
      throw new ParseException("Missing HTTP Authorization header", BearerTokenError.MISSING_TOKEN);
    String[] parts = header.split("\\s", 2);
}


Instance 14

Nonce.parse(final String s){
    if (StringUtils.isBlank(s))
      return null;
    return new Nonce(s);
}


Instance 15

State.parse(final String s){
    if (StringUtils.isBlank(s))
      return null;
    return new State(s);
}


Instance 16

ActiveMQConnectionFactoryProvider.get()#2{
        String jmsUriStr = jmsConfig.getJmsConnectionUrlFormat();
        if (StringUtils.isBlank(jmsUriStr)) {
            throw new ProvisionException(format("JMS URI for %s can not be blank!", annotation == null ? "<default>" : annotation));
        }
}


Instance 17

OAuthModule.OAuthCrypterProvider(@Named("shindig.signing.state-key") String stateCrypterPath)#2{
      if (StringUtils.isBlank(stateCrypterPath)) {
        LOG.info("Using random key for OAuth client-side state encryption");
        crypter = new BasicBlobCrypter(Crypto.getRandomBytes(BasicBlobCrypter.MASTER_KEY_MIN_LEN));
      } else {
        LOG.info("Using file " + stateCrypterPath + " for OAuth client-side state encryption");
        crypter = new BasicBlobCrypter(new File(stateCrypterPath));
      }
}


Instance 18

Instances.process(@NotNull final Config config,final File dist,final File target,final File socketfile)#11{
        for (final String option : config.options()) {
            if (!StringUtils.isBlank(option)) {
                builder.command().add(String.format("--%s", option));
            }
        }
}


Instance 19

OAuthModule.loadDefaultKey(String signingKeyFile,String signingKeyName)#1{
      if (!StringUtils.isBlank(signingKeyFile)) {
        try {
          LOG.info("Loading OAuth signing key from " + signingKeyFile);
          String privateKey = IOUtils.toString(ResourceLoader.open(signingKeyFile), "UTF-8");
          privateKey = BasicOAuthStore.convertFromOpenSsl(privateKey);
          key = new BasicOAuthStoreConsumerKeyAndSecret(null, privateKey, KeyType.RSA_PRIVATE,
              signingKeyName, null);
        } catch (Throwable t) {
          LOG.log(Level.WARNING, "Couldn't load key file " + signingKeyFile, t);
        }
      }
}


Instance 20

HttpResponseFileWriterImpl.writeResponse(final HttpResponse httpResponse,final File httpResponseFile)#0{
            if (!StringUtils.isBlank(httpResponse.getContentType())) {
                writer.write(httpResponse.getContentType());
            }
            writer.newLine();
            writer.close();
}


Instance 21

BearerAccessToken.parse(final HTTPRequest request){
    String authzHeader = request.getAuthorization();
    if (authzHeader != null) {

      return parse(authzHeader);
    }
    Map<String,String> params = request.getQueryParameters();
    String accessTokenValue = params.get("access_token");
    if (StringUtils.isBlank(accessTokenValue))
      throw new ParseException("Missing access token value", BearerTokenError.MISSING_TOKEN);
    return new BearerAccessToken(accessTokenValue);
}


Instance 22

HttpResponseFileReaderImpl.readResponse(final File httpResponseFile,final File httpResponseEntityFile)#1{
            new BufferedReader(new InputStreamReader(new FileInputStream(httpResponseFile), "UTF-8"));
            readNextLine(reader, HTTPCODE);
            final int httpCode = Integer.valueOf(reader.readLine());
            readNextLine(reader, CONTENTTYPE);
            String contentType = reader.readLine();
            if (StringUtils.isBlank(contentType)) {
                contentType = null;
            }
}


Instance 23

AuthorizationErrorResponse.parse(final URI redirectURI,final Map<String,String> params)#0{
    if (StringUtils.isBlank(params.get("error")))
      throw new ParseException("Missing error code");
    String errorURIString = params.get("error_uri");
    if (errorURIString != null) {
      
      try {
        errorURI = new URI(errorURIString);
        
      } catch (URISyntaxException e) {
    
        throw new ParseException("Invalid error URI: " + errorURIString, e);
      }
    }
    ErrorObject error = new ErrorObject(errorCode, errorDescription, HTTPResponse.SC_FOUND, errorURI);
    State state = State.parse(params.get("state"));
    return new AuthorizationErrorResponse(redirectURI, error, null, state);
}


Instance 24

OAuthRequest.exchangeRequestToken()#10{
    String receivedCallback = realRequest.getOAuthArguments().getReceivedCallbackUrl();
    if (!StringUtils.isBlank(receivedCallback)) {
      try {
        Uri parsed = Uri.parse(receivedCallback);
        String verifier = parsed.getQueryParameter(OAuth.OAUTH_VERIFIER);
        if (verifier != null) {
          msgParams.add(new Parameter(OAuth.OAUTH_VERIFIER, verifier));
        }
      } catch (IllegalArgumentException e) {
        throw new OAuthRequestException(OAuthError.INVALID_REQUEST,
            "Invalid received callback URL: " + receivedCallback, e);
      }
    }
}


Instance 25

AuthorizationRequest.parse(final URI uri,final Map<String,String> params)#0{
    String v = params.get("client_id");
    if (StringUtils.isBlank(v)) {
      String msg = "Missing \"client_id\" parameter";
      throw new ParseException(msg, OAuth2Error.INVALID_REQUEST.appendDescription(": " + msg));
    }
    ClientID clientID = new ClientID(v);
    v = params.get("redirect_uri");
    if (StringUtils.isNotBlank(v)) {

      try {
        redirectURI = new URI(v);

      } catch (URISyntaxException e) {
        String msg = "Invalid \"redirect_uri\" parameter: " + e.getMessage();
        throw new ParseException(msg, OAuth2Error.INVALID_REQUEST.appendDescription(": " + msg),
                           clientID, null, null, e);
      }
    }
    State state = State.parse(params.get("state"));
    v = params.get("response_type");
      rt = ResponseType.parse(v);
}